﻿package frEngine.loaders.away3dMd5
{
    import __AS3__.vec.*;
    import flash.geom.*;
    import flash.utils.*;
    import frEngine.core.*;
    import frEngine.loaders.away3dMd5.md5Data.*;
    import frEngine.math.*;
    import frEngine.shader.filters.*;

    public class MD5MeshParserBase extends Object
    {
        public var materialUrl:String;
        public var meshUrl:String = "";
        public static const maxJointCount:int = 3;
        public static var rotationQuat:Quaternion = initRotationQuat();

        public function MD5MeshParserBase(param1:String)
        {
            this.meshUrl = param1;
            return;
        }// end function

        protected function translateGeom(param1:Vector.<VertexData>, param2:Vector.<JointData>, param3:Vector.<uint>, param4:FrSurface3D, param5:int) : void
        {
            var _loc_7:int = 0;
            var _loc_8:int = 0;
            var _loc_9:int = 0;
            var _loc_10:int = 0;
            var _loc_11:int = 0;
            var _loc_12:int = 0;
            var _loc_13:int = 0;
            var _loc_6:* = param3.length / 3;
            _loc_7 = param1.length;
            var _loc_14:* = new Vector.<Number>(_loc_7 * 3);
            var _loc_15:* = new Vector.<Number>(_loc_7 * 3);
            var _loc_16:* = new Vector.<Number>(_loc_7 * param5);
            var _loc_17:* = new Vector.<Number>(_loc_7 * param5);
            var _loc_18:* = new Vector.<Number>(_loc_7 * 2);
            var _loc_19:* = new Vector.<uint>(_loc_6 * 3);
            var _loc_20:int = 0;
            var _loc_21:* = new Dictionary();
            _loc_20 = 0;
            while (_loc_20 < _loc_6)
            {
                
                _loc_11 = _loc_20 * 3;
                _loc_12 = _loc_11 + 1;
                _loc_13 = _loc_11 + 2;
                _loc_8 = param3[_loc_11];
                _loc_9 = param3[_loc_12];
                _loc_10 = param3[_loc_13];
                if (_loc_21[_loc_8] == null)
                {
                    this.pushSanpleTrlData2(_loc_14, _loc_15, _loc_17, _loc_16, _loc_18, param2, param1, _loc_8, _loc_8, param5);
                    _loc_21[_loc_8] = true;
                }
                if (_loc_21[_loc_9] == null)
                {
                    this.pushSanpleTrlData2(_loc_14, _loc_15, _loc_17, _loc_16, _loc_18, param2, param1, _loc_9, _loc_9, param5);
                    _loc_21[_loc_9] = true;
                }
                if (_loc_21[_loc_10] == null)
                {
                    this.pushSanpleTrlData2(_loc_14, _loc_15, _loc_17, _loc_16, _loc_18, param2, param1, _loc_10, _loc_10, param5);
                    _loc_21[_loc_10] = true;
                }
                _loc_19[_loc_11] = _loc_8;
                _loc_19[_loc_12] = _loc_9;
                _loc_19[_loc_13] = _loc_10;
                _loc_20++;
            }
            this.setResultData(param4, _loc_19, _loc_14, _loc_15, _loc_18, _loc_17, _loc_16, param5);
            return;
        }// end function

        private function setResultData(param1:FrSurface3D, param2:Vector.<uint>, param3:Vector.<Number>, param4:Vector.<Number>, param5:Vector.<Number>, param6:Vector.<Number>, param7:Vector.<Number>, param8:int) : void
        {
            var _loc_9:* = param3.length / 3;
            param1.addVertexData(FilterName_ID.POSITION_ID, 3, true, new Data3dInfo(param3, 3, 0, "float3"));
            param1.addVertexData(FilterName_ID.NORMAL_ID, 3, true, new Data3dInfo(param4, 3, 0, "float3"));
            param1.addVertexData(FilterName_ID.UV_ID, 2, true, new Data3dInfo(param5, 2, 0, "float2"));
            param1.addVertexData(FilterName_ID.SKIN_WEIGHTS_ID, param8, true, new Data3dInfo(param6, param8, 0, "float" + param8));
            param1.addVertexData(FilterName_ID.SKIN_INDICES_ID, param8, true, new Data3dInfo(param7, param8, 0, "float" + param8));
            param1.indexVector = param2;
            return;
        }// end function

        private function createLine(param1:Vector.<Number>, param2:Vector.<Number>) : Array
        {
            var _loc_7:Array = null;
            var _loc_8:int = 0;
            var _loc_3:* = param2.length / 3;
            var _loc_4:int = 0;
            var _loc_5:* = new Array();
            var _loc_6:int = 4;
            while (_loc_4 < _loc_3)
            {
                
                _loc_7 = new Array();
                _loc_5.push(_loc_7);
                _loc_8 = _loc_4 * 3;
                _loc_7.push(param2[_loc_8], param2[(_loc_8 + 1)], param2[_loc_8 + 2]);
                _loc_7.push(param2[_loc_8] + param1[_loc_8] * _loc_6, param2[(_loc_8 + 1)] + param1[(_loc_8 + 1)] * _loc_6, param2[_loc_8 + 2] + param1[_loc_8 + 2] * _loc_6);
                _loc_4++;
            }
            return _loc_5;
        }// end function

        private function calculateVertexNormal(param1:Vector.<Number>, param2:Vector.<Number>, param3:Vector.<uint>) : void
        {
            var _loc_8:uint = 0;
            var _loc_9:uint = 0;
            var _loc_10:uint = 0;
            var _loc_11:Number = NaN;
            var _loc_12:Number = NaN;
            var _loc_13:Number = NaN;
            var _loc_14:Number = NaN;
            var _loc_15:Number = NaN;
            var _loc_16:Number = NaN;
            var _loc_17:Number = NaN;
            var _loc_18:Number = NaN;
            var _loc_19:Number = NaN;
            var _loc_20:Number = NaN;
            var _loc_21:Number = NaN;
            var _loc_22:Number = NaN;
            var _loc_23:Number = NaN;
            var _loc_24:Number = NaN;
            var _loc_25:Number = NaN;
            var _loc_26:Number = NaN;
            var _loc_27:Number = NaN;
            var _loc_28:Number = NaN;
            var _loc_29:Number = NaN;
            var _loc_30:Number = NaN;
            var _loc_31:Number = NaN;
            var _loc_32:Number = NaN;
            var _loc_4:* = param2.length;
            var _loc_5:int = 0;
            while (_loc_5 < _loc_4)
            {
                
                param1[_loc_5] = 0;
                _loc_5++;
            }
            var _loc_6:* = param3.length / 3;
            var _loc_7:* = new Dictionary(false);
            _loc_5 = 0;
            while (_loc_5 < _loc_6)
            {
                
                _loc_8 = _loc_5 * 3;
                _loc_9 = _loc_8 + 1;
                _loc_10 = _loc_8 + 2;
                _loc_8 = param3[_loc_8] * 3;
                _loc_9 = param3[_loc_9] * 3;
                _loc_10 = param3[_loc_10] * 3;
                _loc_11 = param2[_loc_8];
                _loc_12 = param2[(_loc_8 + 1)];
                _loc_13 = param2[_loc_8 + 2];
                _loc_14 = param2[_loc_9];
                _loc_15 = param2[(_loc_9 + 1)];
                _loc_16 = param2[_loc_9 + 2];
                _loc_17 = param2[_loc_10];
                _loc_18 = param2[(_loc_10 + 1)];
                _loc_19 = param2[_loc_10 + 2];
                _loc_20 = _loc_11 - _loc_14;
                _loc_21 = _loc_12 - _loc_15;
                _loc_22 = _loc_13 - _loc_16;
                _loc_23 = _loc_14 - _loc_17;
                _loc_24 = _loc_15 - _loc_18;
                _loc_25 = _loc_16 - _loc_19;
                _loc_26 = _loc_17 - _loc_11;
                _loc_27 = _loc_18 - _loc_12;
                _loc_28 = _loc_19 - _loc_13;
                _loc_29 = Math.sqrt(_loc_20 * _loc_20 + _loc_21 * _loc_21 + _loc_22 * _loc_22);
                _loc_20 = _loc_20 / _loc_29;
                _loc_21 = _loc_21 / _loc_29;
                _loc_22 = _loc_22 / _loc_29;
                _loc_29 = Math.sqrt(_loc_23 * _loc_23 + _loc_24 * _loc_24 + _loc_25 * _loc_25);
                _loc_23 = _loc_23 / _loc_29;
                _loc_24 = _loc_24 / _loc_29;
                _loc_25 = _loc_25 / _loc_29;
                _loc_29 = Math.sqrt(_loc_26 * _loc_26 + _loc_27 * _loc_27 + _loc_28 * _loc_28);
                _loc_26 = _loc_26 / _loc_29;
                _loc_27 = _loc_27 / _loc_29;
                _loc_28 = _loc_28 / _loc_29;
                if (_loc_7[_loc_8 + "_" + _loc_9] == null)
                {
                    _loc_30 = param1[_loc_8] + _loc_20;
                    _loc_31 = param1[(_loc_8 + 1)] + _loc_21;
                    _loc_32 = param1[_loc_8 + 2] + _loc_22;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_8] = _loc_30 / _loc_29;
                    param1[(_loc_8 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_8 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_8 + "_" + _loc_9] = true;
                }
                if (_loc_7[_loc_9 + "_" + _loc_8] == null)
                {
                    _loc_30 = param1[_loc_9] - _loc_20;
                    _loc_31 = param1[(_loc_9 + 1)] - _loc_21;
                    _loc_32 = param1[_loc_9 + 2] - _loc_22;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_9] = _loc_30 / _loc_29;
                    param1[(_loc_9 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_9 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_9 + "_" + _loc_8] = true;
                }
                if (_loc_7[_loc_9 + "_" + _loc_10] == null)
                {
                    _loc_30 = param1[_loc_9] + _loc_23;
                    _loc_31 = param1[(_loc_9 + 1)] + _loc_24;
                    _loc_32 = param1[_loc_9 + 2] + _loc_25;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_9] = _loc_30 / _loc_29;
                    param1[(_loc_9 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_9 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_9 + "_" + _loc_10] = true;
                }
                if (_loc_7[_loc_10 + "_" + _loc_9] == null)
                {
                    _loc_30 = param1[_loc_10] - _loc_23;
                    _loc_31 = param1[(_loc_10 + 1)] - _loc_24;
                    _loc_32 = param1[_loc_10 + 2] - _loc_25;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_10] = _loc_30 / _loc_29;
                    param1[(_loc_10 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_10 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_10 + "_" + _loc_9] = true;
                }
                if (_loc_7[_loc_10 + "_" + _loc_8] == null)
                {
                    _loc_30 = param1[_loc_10] + _loc_26;
                    _loc_31 = param1[(_loc_10 + 1)] + _loc_27;
                    _loc_32 = param1[_loc_10 + 2] + _loc_28;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_10] = _loc_30 / _loc_29;
                    param1[(_loc_10 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_10 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_10 + "_" + _loc_8] = true;
                }
                if (_loc_7[_loc_8 + "_" + _loc_10] == null)
                {
                    _loc_30 = param1[_loc_8] - _loc_26;
                    _loc_31 = param1[(_loc_8 + 1)] - _loc_27;
                    _loc_32 = param1[_loc_8 + 2] - _loc_28;
                    _loc_29 = Math.sqrt(_loc_30 * _loc_30 + _loc_31 * _loc_31 + _loc_32 * _loc_32);
                    param1[_loc_8] = _loc_30 / _loc_29;
                    param1[(_loc_8 + 1)] = _loc_31 / _loc_29;
                    param1[_loc_8 + 2] = _loc_32 / _loc_29;
                    _loc_7[_loc_8 + "_" + _loc_10] = true;
                }
                _loc_5++;
            }
            return;
        }// end function

        private function pushSanpleTrlData2(param1:Vector.<Number>, param2:Vector.<Number>, param3:Vector.<Number>, param4:Vector.<Number>, param5:Vector.<Number>, param6:Vector.<JointData>, param7:Vector.<VertexData>, param8:uint, param9:uint, param10:int) : void
        {
            var _loc_25:JointData = null;
            var _loc_11:int = 0;
            var _loc_12:* = param7[param8];
            var _loc_13:* = _loc_12.countWeight;
            var _loc_14:Number = 0;
            var _loc_15:Number = 0;
            var _loc_16:Number = 0;
            var _loc_17:* = _loc_12.startWeight;
            var _loc_18:* = _loc_12.normal;
            var _loc_19:* = _loc_12.pos;
            var _loc_20:Array = [];
            while (_loc_11 < _loc_13)
            {
                
                _loc_25 = param6[_loc_17 + _loc_11];
                _loc_20.push(_loc_25);
                _loc_11++;
            }
            _loc_20.sortOn("bias", Array.NUMERIC | Array.DESCENDING);
            if (_loc_20.length > param10)
            {
                _loc_20.length = param10;
            }
            var _loc_21:* = _loc_20.length;
            if (_loc_21 == 0)
            {
                throw new Error("mesh:" + this.meshUrl + ",独立顶点，没有绑定骨骼，mesh文件有问题");
            }
            var _loc_22:Number = 0;
            _loc_11 = 0;
            while (_loc_11 < _loc_21)
            {
                
                _loc_25 = _loc_20[_loc_11];
                _loc_22 = _loc_22 + _loc_25.bias;
                _loc_11++;
            }
            var _loc_23:* = param9 * param10;
            var _loc_24:int = 0;
            while (_loc_24 < param10)
            {
                
                if (_loc_24 < _loc_21)
                {
                    _loc_25 = _loc_20[_loc_24];
                    param3[_loc_23 + _loc_24] = _loc_25.bias / _loc_22;
                    param4[_loc_23 + _loc_24] = _loc_25.joint * 3;
                }
                else
                {
                    param3[_loc_23 + _loc_24] = 0;
                    param4[_loc_23 + _loc_24] = 0;
                }
                _loc_24++;
            }
            _loc_23 = param9 * 3;
            param1[_loc_23] = _loc_19.x;
            param1[(_loc_23 + 1)] = _loc_19.y;
            param1[_loc_23 + 2] = _loc_19.z;
            param2[_loc_23] = _loc_18.x;
            param2[(_loc_23 + 1)] = _loc_18.y;
            param2[_loc_23 + 2] = _loc_18.z;
            _loc_23 = param9 * 2;
            param5[_loc_23] = _loc_12.s;
            param5[(_loc_23 + 1)] = _loc_12.t;
            return;
        }// end function

        private function pushSanpleTrlData(param1:Vector.<Number>, param2:Vector.<Number>, param3:Vector.<Number>, param4:Vector.<Number>, param5:Vector.<Number>, param6:Vector.<JointData>, param7:Vector.<VertexData>, param8:uint, param9:uint) : void
        {
            var _loc_16:Matrix3D = null;
            var _loc_20:Number = NaN;
            var _loc_21:int = 0;
            var _loc_23:JointData = null;
            var _loc_24:int = 0;
            var _loc_10:int = 0;
            var _loc_11:* = param7[param8];
            var _loc_12:* = _loc_11.countWeight;
            var _loc_13:Number = 0;
            var _loc_14:Number = 0;
            var _loc_15:Number = 0;
            var _loc_17:* = _loc_11.startWeight;
            var _loc_18:* = _loc_11.normal;
            var _loc_19:* = _loc_11.pos;
            var _loc_22:* = param9 * maxJointCount;
            while (_loc_10 < maxJointCount)
            {
                
                if (_loc_10 < _loc_12)
                {
                    _loc_23 = param6[_loc_17 + _loc_10];
                    _loc_24 = _loc_23.joint;
                    _loc_21 = _loc_24 * 3;
                    _loc_20 = _loc_23.bias;
                }
                else
                {
                    _loc_21 = 0;
                    _loc_20 = 0;
                }
                param3[_loc_22 + _loc_10] = _loc_20;
                param4[_loc_22 + _loc_10] = _loc_21;
                _loc_10++;
            }
            _loc_22 = param9 * 3;
            param1[_loc_22] = _loc_19.x;
            param1[(_loc_22 + 1)] = _loc_19.y;
            param1[_loc_22 + 2] = _loc_19.z;
            param2[_loc_22] = _loc_18.x;
            param2[(_loc_22 + 1)] = _loc_18.y;
            param2[_loc_22 + 2] = _loc_18.z;
            _loc_22 = param9 * 2;
            param5[_loc_22] = _loc_11.s;
            param5[(_loc_22 + 1)] = _loc_11.t;
            return;
        }// end function

        private static function initRotationQuat(param1:Vector3D = null, param2:Number = 0) : Quaternion
        {
            var _loc_4:Quaternion = null;
            var _loc_3:* = new Quaternion();
            _loc_3.fromAxisAngle(Vector3D.X_AXIS, (-Math.PI) * 0.5);
            if (param1)
            {
                _loc_4 = new Quaternion();
                _loc_4.fromAxisAngle(param1, param2);
                _loc_3.multiply(_loc_3, _loc_4);
            }
            return _loc_3;
        }// end function

    }
}
